Method and mechanism for reducing client-side memory footprint of transmitted data

ABSTRACT

The present invention is directed to a method and mechanism for reducing the expense of data transmissions between a client and a server. According to an aspect of data prefetching is utilized to predictably retrieve information between the client and server. Another aspect pertains to data redundancy management for reducing the expense of transmitting and storing redundant data between the client and server. Another aspect relates to moved data structures for tracking and managing data at a client in conjunction with data redundancy management.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The invention relates to computer systems, and more particularly to amethod and mechanism for reducing the memory footprint of transmitteddata to a client station.

2. Background

Many computer systems utilize servers, such as “database servers”, tostore and maintain information. In a client-server computer system model(or a multi-tiered computer architecture), users that wish to access ormodify information at the server are often located at a “client”. Tofacilitate the explanation of the invention, the terms “database server”and “database client” may be used in This document in place of “server”and “client”; however, the invention is not limited in its applicabilityto database systems, and indeed, can be utilized in many other types ofcomputer systems.

In client-server systems, users at a database client submit commands tothe database server to store, modify, or retrieve data. In response tothe user commands, data manipulation or query activities are performedat the database server, with data results returned back to the databaseclient for access. In networked environments, the database server oftenperforms data manipulation or query commands submitted by remotelylocated clients. The client may establish a direct connection to thedatabase server over the network, or may establish a connection throughone or more intervening system components, such as an application serveror transaction processing monitor. In either case, the database serverprocesses the user commands and generates appropriate data outputs to bereturned to the client. For example, a common database function is toperform data queries using a database query language such as SQL. Thedatabase server receives each query and generates a query result thatsatisfies the criteria defined by a particular query. The query resultis subsequently transferred to the database client from which the queryoriginated.

Inefficiencies may occur during the processing and transmission of databetween the database server and client. For example, the database serverproduces a result set composed of a quantity of data that can be sent toa database client. The user may initially place an explicit request totransmit a first portion of that result set from the database server tothe client, causing a first set of overhead, such as “network roundtripoverhead”, to be expended. At a later time, the user may request asecond portion of the result set to be transmitted to the client,resulting in another set of overhead to be expended. This process mayproceed until all of the result set is sent, resulting in multiple setsof roundtrip overhead to be expended between the database server and theclient. The expense of sending the data in response to multiple requestsalso includes the wait time that is expended while the, user waits forthe request to be sent to the database server and for the subsequentdata to be sent back to the client. In addition, if the transmitted dataare broken into smaller pieces than the optimum data transfer sizes forthe system, additional overhead is expended. Thus, the more pieces thatthe data set is broken into before transmissions from the server to theclient, the greater the overhead that is likely to be expended.

Another type of inefficiency that may occur is the retransmission ofdata in the returned result set. If the data to be sent to the clientcontains redundancies, then excess overhead, such as increasedtransmission time and data storage at the client, is expended by thesystem to transmit and store that redundant data. When the amount ofdata redundancies is sufficiently large, the excess overhead can have aserious effect upon system performance. Such a circumstance may occur,for example, if the client is querying large database tables with sparsedata for performing queries with joins involving wide tables.

As is evident from the foregoing, inefficiencies may occur as a resultof data transmissions between a database server and a client. These sameinefficiencies may arise from other types of client-server applications,such as for example, a web-based architecture for sending web pages froma web server to a client station having a web browser.

SUMMARY OF THE INVENTION

The present invention is directed to a method and mechanism for reducingthe expense of data transmissions between a client and a server.According to an aspect of the invention, data prefetching is utilized topredictably retrieve information between the client and server. Anotheraspect pertains to data redundancy management for reducing the expenseof transmitting and storing redundant data between the client andserver. Another aspect relates to novel data structures for tracking andmanaging data at a client in conjunction with data redundancymanagement.

Further details of aspects, objects, and advantages of the invention aredescribed below in the detailed description, drawings, and claims.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings are included to provide a furtherunderstanding of the invention and, together with the DetailedDescription, serve to explain the principles of the invention.

FIG. 1 depicts a sample database comprising data to be sent betweenserver and client.

FIGS. 2A-2C illustrate bitmaps having change bits for the table depictedin FIG. 1.

FIG. 3 illustrates data structures utilized in an embodiment of theinvention.

FIG. 4 depicts a process flow for an embodiment of the invention.

FIG. 5 is a diagram of a computer system with which the presentinvention can be implemented.

FIG. 6 is an additional diagram of a computer system with which thepresent invention can be implemented.

DETAILED DESCRIPTION

The present invention is directed to a method and mechanism forincreasing the efficiency of data transfers between a server and aclient. In the following description, for the purposes of explanation,one or more embodiments having specific combinations of elements and/orprocess actions are set forth in order to provide a thoroughunderstanding of the present invention. It will be apparent, however, toone skilled in the art that the present invention may be practiceswithout these specific combinations or order of elements/processactions.

According to an embodiment of the present invention, data access andtransmissions between a server and client are performed using acombination of “prefetching” and data redundancy management. Prefetchingis employed to predictively retrieve information before it is explicitlyrequested by a client. Data redundancy management is employed tominimize the overhead of storing redundant information at the client.According to an aspect of the present invention, this inventivecombination works to significantly reduce the expense and overhead ofretrieving and storing information at a client.

Prefetching refers to the action of transmitting information before itis immediately requested, based upon predictive selection of dataanticipated to be requested by a client in the future. To illustrate theinvention, consider a data result set at a server as shown in table 100of FIG. 1. Table 100 includes four rows of data 108, 110, 112, and 114.Initially, the client may only request a portion of table 100 to be sentfrom the server. This may occur, for example, in systems configured toconserve network bandwidth by allowing the request and transmission ofonly enough information to be sent that can fit onto a client's displaydevice, page, window, or screen at a particular instant in time. Inthese systems, additional portions of the requested data are retrievedonly if specifically requested, e.g., based upon the user scrolling orpaging forward through the displayed data.

The initial request for data results in a certain amount of overhead,including a given quantity of network roundtrips for the user requestfrom the client to server, as well, as the data transmission from serverto client. At a later time, the user may request a second portion of theresult set to be transmitted from the server to client, resulting infurther overhead being expended. This process is inefficient if theoverhead of separately requesting and sending the data in multipleportions is higher than if the data is requested and sent at one time.

Using the prefetching process of the present invention, it can bepredictively anticipated that the client will eventually require moredata than is initially requested. In the case of FIG. 1, it can beanticipated that the entire data of table 100 will be requested by aclient, whether or not only a first portion of table 100 can fit onto adisplay screen. Thus, additional portions of table 100, or even theentire table, are prefetched into a client-side cache, even if only afirst portion is explicitly requested. When the rest of the table 100 isexplicitly requested by the user, rather than sending another request tothe server, the data can be efficiently retrieved from the client'slocal cache.

For an example in another context, consider an Internet web page havinghyperlinks to other web pages/information. If a user requests theInternet web page to be sent to the client, it can be anticipated thatthe user may later wish to retrieve the additional web pages/informationthat are linked into the initial web page. With the present invention,the contents of the linked web pages/information can be prefetched intothe client's local cache. If the user later requests that information,it can immediately be displayed to the user, without requiring any waittime or additional network overhead to request and retrieve thatinformation. An example of a mechanism and process for prefetching datafrom a remote server that can be used in the present invention isdisclosed in U.S. patent application Ser. No. 08/873,644, filed on Jun.11, 1997, which is hereby incorporated by reference in its entirety.

It is possible that some data previously sent and stored at the clientwill be the subject of a later request seeking re-transmission of thesame data to the client. Such transmission of redundant data causesexcess overhead to be expended both in terms of the transmissionoverhead (e.g., excess bandwidth usage) as well as the excess memorycache used at the client to store the redundant data. The presentinvention provides a novel method and mechanism to control thetransmission and storage of redundant data, which can also be usedadvantageously in combination with prefetching.

According to an embodiment of the invention, only data that is changedfrom one row to the next is transmitted from the server to the client.Referring to FIGS. 2A, 2B, and 2C, shown are bitmaps that can be used inan embodiment of the invention to map changes from one row to the next.Each bitmap corresponds to a transition from a first row to a second rowin table 100. Thus, bitmap 200 of FIG. 2A corresponds to the transitionfrom row 108 to row 110 in table 100, bitmap 208 of FIG. 2B correspondsto the transition from row 110 to row 112, and bitmap 216 of FIG. 2Ccorresponds to the transition from row 112 to row 114.

In the bitmaps of FIGS. 2A, 2B, and 2C, each bit represents a transitionfrom one column value of a first row to that same column value in thenext row. A “0” bit represents no change of value from one row to thenext, while a “1” bit represents a change of value. Referring to FIG.2A, bitmap 200 corresponds to the transition from row 108 to 110 intable 100, as stated above. Bit 202 of bitmap 200 corresponds to thetransition from row 108 to row 110 in column 102. Since there is nochange of value from row 108 to row 100 in column 102 (i.e., the columnvalue stayed the same), bit 202 is set at “0”. Similarly, the columnvalue of column 104 did not change from row 108 to row 110. As a result,the corresponding bit 204 in bitmap 200 is set at “0”. However, bit 206in bitmap 200 is set to “1”, since its corresponding transition from row108 to row 110 in column 106 has a change in value from “200” to “300”.

In a similar manner, it can be seen that bits 210, 212, and 214 ofbitmap 208 are set at “1”, “1”, and “0”, respectively, corresponding tochanges/no changes in value between rows 110 to 112 in table 100.Likewise, bits 218, 220, and 222 in bitmap 216 are set at “1”, “1”, and“1”, respectively, corresponding to changes in value between rows 112and 114 in table 100.

To reduce the transmission of redundant data in table 100 from server toclient, table 100 is checked to determine whether redundant data betweenone row and the next is being requested. Bitmaps 200, 208, and 216 canbe checked to make this determination. Only data that changes from onerow to the next will be sent from server to client. As noted above,changed data corresponds to the value of “1” for each bit in the bitmaps200, 208, and 216.

FIG. 3 illustrates data structures at a client 304 that can be used tostore and track the data that is sent from a server 302 to the client304. For the convenience of the reader, database table 100 is reprintedand shown as the database table being sent from server 302 to client304. Cache 308 represents the memory cache at client 304 that storesdata sent from server 302.

In operation, a portion of table 100 from server 302 is explicitlyrequested for delivery to client 304. If prefetching is used, then agreater portion, or even all, of table 100 is sent in response to theuser/client request. For purposes of this example, it is assumed thatthe entirety of table 100 is prefetched to client 304. Initially, all ofrow 108 would be sent from server 302 to client 304 over network 306.Thus, the values “100”, “Joe”, and “200” corresponding to columns 102,104, and 106 of row 108 would be sent to client 304, and stored in cachesections 310, 312, and 314, respectively.

At client 304, data structures are maintained to allow a user to accessthe data that is received. In an embodiment, the data structurescorrespond to the types of data that are transmitted from server toclient. Thus, data structure 328, corresponding to row 108 of table 100,contains pointers to each of the column values for row 108 in table 100.In particular, the pointers in data structure 328 point to cachesections 310, 312, and 314 of cache 308, which correspond to the localcopy of row 108, and these pointers are used by .a user at client 304 toaccess these cached values.

Additional data structures are employed to track each row of data thatis transmitted form server 302 to client 304. Thus, data structure 330contains pointers to the cache sections containing values for row 110 oftable 100. Similarly, data structures 332 and 334 contain pointers tothe cache sections containing values for rows 112 and 114, respectively,of table 100 sent from server 302 to client 304.

After the first row 108 of table 100 is sent from server 302 to client304, any transmission of additional rows results in the possibility thatredundant data for column values will be requested for transmissionacross network 306. Thus bitmaps 200, 208, and 216 are consulted in anembodiment of the invention to determine whether a next-row redundantdata value is being sent. If a next-row redundant data value situationoccurs, then the redundant data value is not sent across network 306.Instead, the corresponding data structure at client 304 is configured topoint to the previous copy that has already been transmitted.

Consider the values of row 110 in table 100. A review of rows 108 and110 in column 102 of table 100 shows that there is no change in thecolumn value. A similar review of these rows in column 104 shows thatthere is again no change in value. However, inspection of rows 108 and110 in column 106 shows that the column value changes from “200” to“300”. In this circumstance, only the changed column value (i.e., “300”in row 110, column 106 of table 100) is sent from server 302 to client304. This changed column value is stored in cache section 316 of cache308.

The data structure 330 for row 110 is configured to point to cachesection 316 for its representation of column 106. However, for theunchanged column values that did not get transmitted from server 302 toclient 304, data structure 330 is configured to point to existing cachesections that contain the redundant data. Thus, the pointer in datastructure 330 corresponding to column 102 points to cache section 310(which is also pointed to by the data structure pointer 328corresponding to column 102 for row 108 of table 100). The pointer indata structure 330 corresponding to column 104 points to cache section312 (which is also pointed to by the data structure pointer 328corresponding to column 104 for row 108).

In an equivalent manner, it can be seen that only the values for columns102 and 104 in row 112 differ from it preceding row 110. The columnvalue for row 112 did not change in the transition from row 110 to 112.Thus, only the values for columns 102 and 104 in row 112 are transmittedfrom server 302 to client 304. These transmitted values are stored incache sections 318 and 320. In the data structure 332 for row 112, itcan be seen that pointers for columns 102 and 104 point to these newlyfilled cache sections, but the pointer for column 106 points to a cachesection 316 previously filled for row 110.

For row 114, it can be seen that every column has a value that differsfrom its value in the preceding row. Thus, every column value istransmitted from server 302 to client 304, which is then stored in cache308. Thus, cache section 322, 324, and 326 are used to store the valuesof row 144 transmitted to client 304. Data structure 334, whichcorresponds to row 114 in table 100, contains pointers that point toeach of these newly filled cache sections.

While the embodiment just discussed only performs a data redundancycheck for one preceding row, the invention can be extended to check ordata redundancy across multiple previous rows. The data structuresmaintained form each row can point to any cache section in cache 308,even for cache sections filled by row values beyond just the immediatelypreceding row.

To track changes across multiple rows, a multidimensional bitmap can bemaintained to track changes across multiple rows. Thus, the bitmap wouldcontain multiple bits for each column-row pair, corresponding to anindication of value change for several preceding rows for that samecolumn.

Instead of, or in addition to the use of a multidimensional bitmap, anadditional optimization comprises a scan of cache 308 to eliminateredundant data storage, without the use of bitmaps to reduce thetransmission of data redundancies. In this optimization, the redundantdata in cache 308 are removed after they have been transmitted fromserver 302 to client 304 (which reduces cache usage at the client), andpointers in the data structures are reorganized to all point to thereduced and consolidated number of column values.

FIG. 4 depicts an embodiment of a process flow that can be used tocombine prefetching and data redundancy management to control datatransmissions between a server 302 and client 304. Initially, the datathat is immediately being requested by a client 304 is identified (402).Based upon the immediately requested data, a determination is madewhether there exists any identifiable data to be prefetched to theclient (404). This determination is made in a predictive manner basedupon several factors. Such factors could include, for example, any datacompression ratio that are being used or established. If the ratio istoo small, data redundancy management can be turned off.

If such data is identified, a determination is then made whether it isadvantageous to perform compression data redundancy management orprefetch the identified data (406). Some types of data can be identifiedas being very likely to be requested in the immediate future by theclient, and these types of data render it more likely of an advantage toprefetch. For example, if a client requests only a first portion of aresult set or database table result, then the remaining data in theresult set/database table set is very likely to be needed by the client.The cost of sending the identified data immediately and the likelihoodof the client actually requesting the identified data can be consideredin light of the additional overhead to be expended if the client makesthe additional requests later to determine whether prefetching would beadvantageous. If it is advantageous to prefetch, then prefetching isemployed to send the additional data to the client (408). In analternative embodiment, prefetching can be performed as an “on” or “off”option. When prefetching is turned on, the above-described process fordetermining advantages to prefetching need not be performed.

Before the identified prefetched data is sent to client 304, adetermination is made whether there exists redundant data to be sent(410). For example, bitmap records can be reviewed to detectcolumn-to-column changes/no changes in database row values. If dataredundancies exist, then a reduced data set is sent from the server toclient (412), and their corresponding data structures at client 304 areconfigured to point to shared cache space for multiple rows (413). If nodata redundancies are detected, then the entire data set is transmittedfrom server 302 to client 304 (414).

To increase accuracy of predicting costs for transmitting prefetcheddata, the size of data values can be transmitted along with the datavalues themselves. Thus, the memory cache 308 in FIG. 3 includesadditional fields for the size of data values that lend themselves to bedescribed in this manner, e.g., string values. Other methods forreducing the transmission of redundant data may also be employed in theinvention in combination with prefetching (e.g., U.S. application Ser.No. 09/086,753, filed on May 29, 1998, which is hereby incorporated byreference in its entirety).

System Architecture Overview

Referring to FIG. 5, in an embodiment, a computer system 520 includes ahost computer 522 connected to a plurality of individual user stations524. In an embodiment, the user stations 524 each comprise suitable dataterminals, for example, but not limited to, e.g., personal computers,portable laptop computers, or personal data assistants (“PDAs”), whichcan store and independently run one or more applications, i.e.,programs. For purposes of illustration, some of the user stations 524are connected to the host computer 522 via a local area network (“LAN”)526. Other user stations 524 are remotely connected to the host computer522 via a public telephone switched network (“PSTN”) 528 and/or awireless network 530.

In an embodiment, the host computer 522 operates in conjunction with adata storage system 531, wherein the data storage system 531 contains adatabase 532 that is readily accessible by the host computer 522.

In alternative embodiments, the database 532 may be resident on the hostcomputer, stored, e.g., in the host computer's ROM, PROM, EPROM, or anyother memory chip, and/or its hard disk. In yet alternative embodiments,the database 532 may be read by the host computer 522 from one or morefloppy disks, flexible disks, magnetic tapes, any other magnetic medium,CD-ROMs, any other optical medium, punchcards, papertape, or any otherphysical medium with patterns of holes, or any other medium from which acomputer can read.

In an alternative embodiment, the host computer 522 can access two ormore databases 532, stored in a variety of mediums, as previouslydiscussed.

Referring to FIG. 6, in an embodiment, each user station 524 and thehost computer 522, each referred to generally as a processing unit,embodies a general architecture 605. A processing unit includes a bus606 or other communication mechanism for communicating instructions,messages and data, collectively, information; and one or more processors607 coupled with the bus 606 for processing information.. A processingunit also includes a main memory 608, such as a random access memory(RAM) or other dynamic storage device, coupled to the bus 606 forstoring dynamic data and instructions to be executed by the processor(s)607. The main memory 608 also may be used for storing temporary data,i.e., variables, or other intermediate information during execution ofinstructions by the processor(s) 607.

A processing unit may further include a read only memory (ROM) 609 orother static storage device coupled to the bus 606 for storing staticdata and instructions for the processor(s) 607. A storage device 610,such as a magnetic disk or optical disk, may also be provided andcoupled to the bus 606 for storing data and instructions for theprocessor(s) 607.

A processing unit may be coupled via the bus 606 to a display device611, such as, but not limited to, a cathode ray tube (CRT), fordisplaying information to a user. An input device 612, includingalphanumeric and other keys, is coupled to the bus 606 for communicatinginformation and command selections to the processor(s) 607. Another typeof user input device may include a cursor control 613, such as, but notlimited to, a mouse, a trackball, a fingerpad, or cursor direction keys,for communicating direction information and command selections to theprocessor(s) 607 and for controlling cursor movement on the display 611.

According to one embodiment of the invention, the individual processingunits perform specific operations by their respective processor(s) 607executing one or more sequences of one or more instructions contained inthe main memory 608. Such instructions may be read into the main memory608 from another computer-usable medium, such as the ROM 609 or thestorage device 610. Execution of the sequences of instructions containedin the main memory 608 causes the processor(s) 607 to perform theprocesses described herein. In alternative embodiments, hard-wiredcircuitry may be used in place of or in combination with softwareinstructions to implement the invention. Thus, embodiments of theinvention are not limited to any specific combination of hardwarecircuitry and/or software.

The term “computer-usable medium,” as used herein, refers to any mediumthat provides information or is usable by the processor(s) 607. Such amedium may take many forms, including, but not limited to, non-volatile,volatile and transmission media. Non-volatile media, i.e., media thatcan retain information in the absence of power, includes the ROM 609.Volatile media, i.e., media that can not retain information in theabsence of power, includes the main memory 608. Transmission mediaincludes coaxial cables, copper wire and fiber optics, including thewires that comprise the bus 606. Transmission media can also take theform of carrier waves; i.e., electromagnetic waves that can bemodulated, as in frequency, amplitude or phase, to transmit informationsignals. Additionally, transmission media can take the form of acousticor light waves, such as those generated during radio wave and infrareddata communications.

Common forms of computer-usable media include, for example: a floppydisk, flexible disk, hard disk, magnetic tape, any other magneticmedium, CD-ROM, any other optical medium, punchcards, papertape, anyother physical medium with patterns of holes, RAM, ROM, PROM (i.e.,programmable read only memory), EPROM (i.e., erasable programmable readonly memory), including FLASH-EPROM, any other memory chip or cartridge,carrier waves, or any other medium from which a processor 607 canretrieve information.

Various forms of computer-usable media may be involved in providing oneor more sequences of one or more instructions to the processor(s) 607for execution. For example, the instructions may initially be providedon a magnetic disk of a remote computer (not shown). The remote computermay load the instructions into its dynamic memory and then transit themover a telephone line, using a modem. A modem local to the processingunit may receive the instructions on a telephone line and use aninfrared transmitter to convert the instruction signals transmitted overthe telephone line to corresponding infrared signals.

An infrared detector (not shown) coupled to the bus 606 may receive theinfrared signals and place the instructions therein on the bus 606. Thebus 606 may carry the instructions to the main memory 608, from whichthe processor(s) 607 thereafter retrieves and executes the instructions.The instructions received by the main memory 608 may optionally bestored on the storage device 610, either before or after their executionby the processor(s) 607.

Each processing unit may also include a communication interface 614coupled to the bus 606. The communication interface 614 provides two-waycommunication between the respective user stations 524 and the hostcomputer 522. The communication interface 614 of a respective processingunit transmits and receives electrical, electromagnetic or opticalsignals that include data streams representing various types ofinformation, including instructions, messages and data.

A communication link 615 links a respective user station 524 and a hostcomputer 522. The communication link 615 may be a LAN 526, in which casethe communication interface 614 may be a LAN card. Alternatively, thecommunication link 615 may be a PSTN 528, in which case thecommunication interface 614 may be an integrated services digitalnetwork (ISDN) card or a modem. Also, as a further alternative, thecommunication link 615 may be a wireless network 530.

A processing unit may transmit and receive messages, data, andinstructions, including program, i.e., application, code, through itsrespective communication link 615 and communication interface 614.Received program code may be executed by the respective processor(s) 607as it is received, and/or stored in the storage device 610, or otherassociated non-volatile media, for later execution. In this manner, aprocessing unit may receive messages, data and/or program code in theform of a carrier wave.

In the foregoing specification, the invention has been described withreference to specific embodiments thereof. It will, however, be. evidentthat various modifications and changes may be made thereto withoutdeparting from the broader spirit and scope of the invention. Forexample, the reader is to understand that the specific ordering andcombination of process actions shown in the process flow diagramsdescribed herein is merely illustrative, and the invention can beperformed using different or additional process actions, or a differentcombination or ordering of process actions. The specification anddrawings are, accordingly, to be regarded in an illustrative rather thanrestrictive sense.

1-23. (canceled)
 24. A computer-implemented process for increasing datastorage efficiency, comprising: identifying a first set of data;determining, using a processor, the existence of data redundancies inthe first set of data, wherein the existence of data redundancies isdetermined by calculating row differences between successive rows of thefirst set of data to generate a bitmap, and wherein a second set of datais obtained by consulting the bitmap corresponding to changes between afirst row and a second row of the first set of data; and obtaining thesecond set of data that is a reduced version of the first set of data,wherein the second set of data does not include the data redundanciesdetermined in the first set of data.
 25. The process of claim 24,wherein calculating the row differences between successive rows in thefirst set of data is performed by identifying identical column valuesfor the successive rows.
 26. The process of claim 24, wherein the bitmapcomprises a bit having a value of “1,” the bit representing thedifference between two data in the first set of data.
 27. The process ofclaim 24, wherein the bitmap comprises a bit having a value of “0,” thebit representing a redundancy of data in the first set of data.
 28. Theprocess of claim 24, wherein consulting the bitmap is performed byevaluating each bit in the bitmap to determine changes between the firstrow and the second row.
 29. The process of claim 24, wherein the secondset of data is associated with a first bit map that corresponds with afirst row difference between a first row and a second row of data in thefirst set of data.
 30. The process of claim 29, wherein the second setof data is associated with a second bit map that corresponds with asecond row difference between the second row and a third row of data inthe first set of data.
 31. The process of claim 24, wherein the bitmapis a multidimensional bit map.
 32. The process of claim 24, where thefirst and second rows are not consecutive rows.
 33. The process of claim24, wherein the second set of data comprises a smaller memory footprintthan the first set of data.
 34. A computer program product that includesa volatile or non-volatile computer-usable medium usable by a processor,the medium having stored thereon a sequence of instructions which, whenexecuted by said processor, causes said processor to execute a processfor increasing the efficiency of data storage, said process comprising:identifying a first set of data; determining the existence of dataredundancies in the first set of data, wherein the existence of dataredundancies is determined by calculating row differences betweensuccessive rows of the first set of data to generate a bitmap, andwherein a second set of data is obtained by consulting the bitmapcorresponding to changes between a first row and a second row of thefirst set of data; and obtaining the second set of data that is areduced version of the first set of data, wherein the second set of datadoes not include the data redundancies determined in the first set ofdata.
 35. The computer program product of claim 34, wherein calculatingthe row differences between successive rows in the first set of data isperformed by identifying identical column values for the successiverows.
 36. The computer program product of claim 34, wherein consultingthe bitmap is performed by evaluating each bit in the bitmap todetermine changes between the first row and the second row.
 37. Thecomputer program product of claim 34, wherein the bitmap is amultidimensional bit map.
 38. The computer program product of claim 34,where the first and second rows are not consecutive rows.
 39. Thecomputer program product of claim 34, wherein the second set of datacomprises a smaller memory footprint than the first set of data.
 40. Acomputer system comprising a server, the computer system configured toincrease the efficiency of data storage at the server by: identifying afirst set of data; determining the existence of data redundancies in thefirst set of data, wherein the existence of data redundancies isdetermined by calculating row differences between successive rows of thefirst set of data to generate a bitmap, and wherein a second set of datais obtained by consulting the bitmap corresponding to changes between afirst row and a second row of the first set of data; and obtaining thesecond set of data that is a reduced version of the first set of data,wherein the second set of data does not include the data redundanciesdetermined in the first set of data.
 41. The computer system of claim40, wherein calculating the row differences between successive rows inthe first set of data is performed by identifying identical columnvalues for the successive rows.
 42. The computer system of claim 40,wherein consulting the bitmap is performed by evaluating each bit in thebitmap to determine changes between the first row and the second row.43. The computer system of claim 40, wherein the bitmap is amultidimensional bit map.
 44. The computer system of claim 40, where thefirst and second rows are not consecutive rows.
 45. The computer systemof claim 40, wherein the second set of data comprises a smaller memoryfootprint than the first set of data.
 46. A computer-implemented processfor increasing data storage efficiency, comprising: storing a second setof data that is a reduced version of a first set of data, wherein thesecond set of data does not include data redundancies determined in thefirst set of data and wherein the data redundancies are determined bycalculating row differences between successive rows of the first set ofdata to generate a bitmap, and wherein the second set of data isobtained by consulting the bitmap corresponding to changes between afirst row and a second row of the first set of data; and configuring,using a processor, a plurality of data elements associated withredundant data in the first set of data to point to a same data item inthe second set of data such that the same data item is accessed for theplurality of data elements.
 47. The process of claim 46, whereincalculating the row differences between successive rows in the first setof data is performed by identifying identical column values for thesuccessive rows.
 48. The process of claim 46, wherein consulting thebitmap is performed by evaluating each bit in the bitmap to determinechanges between the first row and the second row.
 49. The process ofclaim 46, wherein the first and the second rows are not consecutive rowsof the database table.
 50. The process of claim 46, wherein the secondset of data comprises a smaller memory footprint than the first set ofdata.
 51. The process of claim 46, wherein the second set of data isassociated with a first bit map that corresponds with a first rowdifference between a first row and a second row of data in the first setof data.
 52. The process of claim 46, wherein the second set of data isassociated with a second bit map that corresponds with a second rowdifference between the second row and a third row of data in the firstset of data.
 53. A computer program product that includes a volatile ornon-volatile computer-usable medium usable by a processor, the mediumhaving stored thereon a sequence of instructions which, when executed bysaid processor, causes said processor to execute a process forincreasing the efficiency of data storage, said process comprising:storing a second set of data that is a reduced version of a first set ofdata, wherein the second set of data does not include data redundanciesdetermined in the first set of data and wherein the data redundanciesare determined by calculating row differences between successive rows ofthe first set of data to generate a bitmap, and wherein the second setof data is obtained by consulting the bitmap corresponding to changesbetween a first row and a second row of the first set of data; andconfiguring a plurality of data elements associated with redundant datain the first set of data to point to a same data item in the second setof data such that the same data item is accessed for the plurality ofdata elements.
 54. The product of claim 53, wherein calculating the rowdifferences between successive rows in the first set of data isperformed by identifying identical column values for the successiverows.
 55. A computer system comprising: a processor; a display deviceand/or a volatile or non-volatile computer-usable medium, wherein thesystem is configured to storing a second set of data that is a reducedversion of a first set of data, wherein the second set of data does notinclude data redundancies determined in the first set of data andwherein the data redundancies are determined by calculating rowdifferences between successive rows of the first set of data to generatea bitmap, and wherein the second set of data is obtained by consultingthe bitmap corresponding to changes between a first row and a second rowof the first set of data; and configuring a plurality of data elementsassociated with redundant data in the first set of data to point to asame data item in the second set of data such that the same data item isaccessed for the plurality of data elements.
 56. The system of claim 55wherein calculating the row differences between successive rows in thefirst set of data is performed by identifying identical column valuesfor the successive rows.